Спринт 3/18 → Тема 1/3: Самое необходимое об ООП → Урок 2/8

Классы в Python

Чтобы написать программу с учётом парадигмы ООП, нужно использовать классы. Из этого урока вы узнаете, что такое классы в Python, а также потренируетесь создавать классы и их экземпляры (объекты).

Стандартные типы Python — это классы

В Python каждая переменная содержит экземпляр какого-то класса.

Если вы напишете spell = 'Stupefy' — будет создан объект spell типа str (строка), обладающий всеми свойствами и методами, присущими классу str, например lower или split. Такая логика справедлива для всех встроенных типов данных, будь то int, set, dict или любой другой тип.

Все создаваемые вами функции — это тоже объекты, экземпляры класса function. Запустите код и убедитесь в этом:

КодPYTHON

 
def cast_spell():
    return  'Expecto Patronum'
​
# Выведем на печать тип объекта.
print(type(cast_spell))

Кроме стандартных типов данных в Python можно использовать свои типы данных. То есть разработчик может создавать свои собственные классы со своими переменными и методами.

Создание классов в Python

Для создания класса используется оператор class, после оператора указывается имя класса.

Имена классам принято задавать по правилам:

имя класса должно начинаться с большой буквы;
если имя класса состоит из нескольких слов, то используется CamelCase, то есть каждое слово пишется с большой буквы, между словами не используются пробелы, например TomReddl;
имя класса должно быть в единственном числе, например Car, но не Cars.

Классы и их экземпляры обладают методами и атрибутами.

Вы можете сами определять необходимые методы и атрибуты класса, однако существуют предопределённые методы, одним из них является __init__. Он отвечает за инициализацию объектов класса. Это специальная функция для создания объектов; её ещё называют конструктор класса.

В метод передаются параметры. Первый обязательный параметр для всех методов, объявленных в классе, — self (англ. «сам»).

Параметр self нужен для того, чтобы созданный объект мог обратиться к собственным методам или свойствам.

После параметра self передаются остальные параметры конструктора, а в теле метода __init__ объявляются свойства класса.

В итоге общий вид объявления класса выглядит так:

PYTHON
class <Имя класса>:
    # Конструктор класса — функция с именем __init__.
    def __init__(self, param1): # Параметры конструктора класса.
        # Объявление атрибутов.
        self.atr = param1
    # Объявление метода.
    def metod(self):
        # Код метода. 

Пишем первый класс

В прошлом уроке вы знакомились с понятием класса на примере эскиза меча. Объекты этого класса должны обладать следующими свойствами:

название,
материал клинка,
длина клинка,
тип рукояти.

Методы объекта таковы:

«нанести рубящий удар»,
«выполнить укол»,
«заточить клинок».

Опишем всё это кодом:

PYTHON
# Объявляем класс и задаём ему имя.
class Sword:
    # Объявляем конструктор класса и указываем все необходимые параметры: 
    # обязательный параметр self, название меча, материал клинка, 
    # длину клинка, тип рукояти.
    def __init__(self, name, material, blade_length, grip):
        # Объявляем свойства класса и передаём в них необходимые значения.
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        # Когда объект будет создан, выведется сообщение.
        print(f'Новый меч {name} выкован!')

    # Объявляем собственные методы,
    # в которых используются значения свойств класса Sword.
    # Метод «Нанести рубящий удар».
    def slashing_blow(self):
        return (f'Нанесён рубящий удар мечом {self.name}. '
                f'Радиус поражения: {self.blade_length}.')
    
    # Метод «Выполнить укол».
    def piercing_strike(self):
        return (f'Нанесён пронзающий удар мечом {self.name}. '
                f'Рукоять {self.grip} мягко легла в руку.')

    # Метод «Заточить клинок».
    def sharpen(self):
        return (f'Меч "{self.name}" заточен,'
                f' {self.material} отлично поддалась обработке.') 

Свойства класса объявляются через точечную нотацию, потому что self — это ссылка на экземпляр класса (конкретный объект).

Например, строка self.name = name запишет в свойство объекта self.name значение, которое было передано в параметр name и получено при вызове конструктора класса.

❗ Параметры, принимаемые конструктором, и переменные (свойства) в его теле — не одно и то же, даже если у них одинаковые имена. Например, name — это параметр класса, а self.name — переменная конкретного (self — «сам») объекта.

Обратите внимание и на то, что конструктор класса может не только присваивать значения свойствам, но и вызывать функции прямо в момент создания объекта. В примере выше реализовано подобное поведение. Это строка кода, которая печатает сообщение о создании нового объекта:

PYTHON
...
    print(f'Новый меч {name} выкован!')
... 

После конструктора класса описываются методы класса. По сути это функции, которые можно вызывать для работы с объектами класса. В случае с мечами — это функции slashing_blow(), piercing_strike() и sharpen().

Объекты в Python

Класс (читай — эскиз) создан, теперь можно создать объекты.

Чтобы создать объект, нужно создать экземпляр класса, передав в класс требуемые параметры. Для обращения к объекту по имени можно «положить» его в переменную. Запустите код:

КодPYTHON

 
class Sword:
​
    def __init__(self, name, material, blade_length, grip):
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        print(f'Новый меч {name} выкован!')
    
    def slashing_blow(self):
        return (f'Нанесён рубящий удар мечом {self.name}. '
                f'Радиус поражения: {self.blade_length}.')
​
    def piercing_strike(self):
        return (f'Нанесён пронзающий удар мечом {self.name}. '
                f'Рукоять {self.grip} мягко легла в руку.')
​
    def sharpen(self):
        return (f'Меч "{self.name}" заточен,'
                f' {self.material} отлично поддалась обработке.')
​
# Создаём экземпляр класса Sword.
first_sword = Sword('Тренировочный',
                    'Кора железного дуба',
                    1.2, 'хват одной рукой')
​
print('Перед вами манекен, опробуйте удары на нём.')
# Вызвать метод рубящего удара.
print(first_sword.slashing_blow())
# Вызвать метод пронзающего удара.
print(first_sword.piercing_strike())
print('Обслуженное оружие никогда не подведёт.')
# Вызвать метод заточки меча.
print(first_sword.sharpen())

Результат — «под капотом» появился класс, который вы можете использовать для того, чтобы создавать разнообразные объекты. Сколько же мечей можно выковать — не сосчитать!

Значения по умолчанию в методах и свойствах класса

Как и для обычных функций, для методов класса можно указывать значения параметров по умолчанию.

Обратимся к примеру с мечами. Здесь можно указать стандартный материал для изготовления мечей, пусть это будет сталь. Да, без изысков, но зато всегда в наличии.

Код класса с параметром по умолчанию будет выглядеть так:

PYTHON
class Sword:

        # У параметра material указано значение по умолчанию.
    # Параметры со значениями по умолчанию всегда указываются в конце.
    def __init__(self, name, blade_length, grip, material='сталь'):
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        print(f'Новый меч {name} выкован!')
    
    def slashing_blow(self):
        ...

    def piercing_strike(self):
        ...

    def sharpen(self):
        ... 

Параметры класса со значением по умолчанию ещё называют необязательными, потому что при создании экземпляра класса в них можно ничего не передавать.

❗ Параметры со значением по умолчанию нужно записывать после параметров без значений по умолчанию. Иначе, когда вы будете создавать экземпляр класса, придётся передавать эти значения, и смысл параметров со значением по умолчанию потеряется.

В свойствах класса также можно задать значение по умолчанию, необязательно передавать его из параметров.

Без примера не обойтись. Вернёмся к мечам.

У каждого меча есть свойство strength — прочность. Также есть методы, которые отвечают за нанесение рубящего удара slashing_blow() и пронизывающего piercing_strike(). Когда мечом наносится удар, его прочность должна падать. А метод заточки меча sharpen() призван возвращать исходную прочность.

Чтобы реализовать подобное поведение программы, воспользуемся возможностью задавать в свойствах класса значения по умолчанию. Запустите код и внимательно прочитайте комментарии, они помогут вам сориентироваться:

КодPYTHON

print(classic_sword.strength)
class Sword:
​
    def __init__(self, name, blade_length, grip, material='сталь'):
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        # Задаём стартовую прочность для всех мечей (всех объектов).
        self.strength = 100
        print(f'Новый меч {name} выкован!')
    
    def slashing_blow(self):
        # При рубящем ударе уменьшаем прочность меча на 10.
        self.strength -= 10
        return (f'Нанесён рубящий удар мечом {self.name}. '
                f'Радиус поражения: {self.blade_length}.')
​
    def piercing_strike(self):
        # При пронзающем ударе уменьшаем прочность меча на 5.
        self.strength -= 5
        return (f'Нанесён пронзающий удар мечом {self.name}. '
                f'Рукоять {self.grip} мягко легла в руку.')
​
    def sharpen(self):
        # При заточке меча восстанавливаем стартовую прочность меча.
        self.strength = 100
        return (f'Меч "{self.name}" заточен,'
                f' {self.material} отлично поддалась обработке.')
​
​
# Создаём экземпляр класса: меч Верный.
katana = Sword('Верный', 1.5,
               'под хват двумя руками')
# Создаём ещё один экземпляр класса: меч Дежурный.
classic_sword = Sword('Дежурный', 1.2,
                      'под хват одной рукой')
​
# Наносим один удар мечом Верный.
print(katana.slashing_blow())
​

Стартовая прочность мечей была 100. Далее каждым из мечей были нанесены удары, и их прочность уменьшилась до 90 и 75.

Из одного класса было создано два разных объекта. При создании у них было одинаковое состояние. Но далее для каждого объекта было вызвано разное количество методов, как итог — разное состояние у объектов.

Это говорит о том, что в методе класса можно менять значение его свойств. Ещё один вывод — значение свойств для каждого созданного объекта зависит только от изменений внутри самого объекта.

Что лежит в объекте?

Так как объект может менять своё состояние, иногда полезно знать, в каком состоянии этот объект находится в текущий момент. Когда код маленький и свой, с этим вопросом разобраться не так уж и сложно. А когда код большой и чужой — одного взгляда в редактор кода может быть недостаточно. Тогда можно напечатать содержимое объекта.

Любая строка и любое число — это объекты, экземпляры классов. Напечатать их на экране — проще простого:

КодPYTHON

 
# При создании экземпляра класса str
# нет необходимости указывать имя родительского класса
# Python сам понимает: раз в кавычках — значит, str.
spell = 'Stupefy'
​
print(spell)

Объекты katana и classic_sword — это тоже экземпляры класса, их тоже можно распечатать:

КодPYTHON

 
class Sword:
​
    def __init__(self, name, blade_length, grip, material='сталь'):
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        self.strength = 100 
        print(f'Новый меч {name} выкован!')
    
    def slashing_blow(self):
        self.strength -= 10
        return (f'Нанесён рубящий удар мечом {self.name}. '
                f'Радиус поражения: {self.blade_length}.')
​
    def piercing_strike(self):
        self.strength -= 5
        return (f'Нанесён пронзающий удар мечом {self.name}. '
                f'Рукоять {self.grip} мягко легла в руку.')
​
    def sharpen(self):
        self.strength = 100
        return (f'Меч "{self.name}" заточен,'
                f' {self.material} отлично поддалась обработке.')
​
​
katana = Sword('Верный', 1.5,
               'хват двумя руками')
classic_sword = Sword('Дежурный', 1.2,
                      'хват одной рукой')
​
# Печатаем созданные объекты.
print(katana)
print(classic_sword)
​

Получилось не так красиво, как со строкой: Python вывел на экран имя родительского класса и адрес в памяти, где сохранён объект.

Чтобы вывод был более понятным и содержательным, используется метод __str__. В стандартных классах этот метод описан по умолчанию, а вот в пользовательских классах разработчик должен описать его самостоятельно.

❗ Метод __str__ должен возвращать только строковое значение.

Запустите код и посмотрите, что получится:

КодPYTHON

 
class Sword:
​
    def __init__(self, name, blade_length, grip, material='сталь'):
        self.name = name
        self.blade_length = blade_length
        self.material = material
        self.grip = grip
        self.strength = 10
        print(f'Новый меч {name} выкован!')
    
    def slashing_blow(self):
        self.strength -= 10
        return (f'Нанесён рубящий удар мечом {self.name}. '
                f'Радиус поражения: {self.blade_length}.')
​
    def piercing_strike(self):
        self.strength -= 5
        return (f'Нанесён пронзающий удар мечом {self.name}. '
                f'Рукоять {self.grip} мягко легла в руку.')
​
    def sharpen(self):
        self.strength = 100
        return (f'Меч "{self.name}" заточен,'
                f' {self.material} отлично поддалась обработке.')
    
    # Вот он — новый метод! Именно в нём описывается то, что должно выводиться
    # при печати объекта.
    def __str__(self):
        # Можно задать любую строку, например
        # «Не печатай меня, ведь я — объект!».
        # Но лучше пусть при печати выводится что-то осмысленное,
        # например имя объекта и его основные параметры.
        return (
            f'Меч — «{self.name}». ' 
            f'Выкован из материала {self.material}, '
            f'длина клинка — {self.blade_length}, '
            f'прочность — {self.strength}.'
        )
​
​
katana = Sword('Верный', 1.5,
               'хват двумя руками')
classic_sword = Sword('Дежурный', 1.2,
                      'хват одной рукой')
​
# Печатаем созданные объекты.
print(katana)
print(classic_sword)

Такой вывод в терминале выглядит более содержательно и понятно.

Классы — done!

Вы потренировались создавать классы и объекты, узнали, что значения в методах классов можно задавать по умолчанию, а также научились «печатать» объекты. Теперь любой ~~кузнец~~ разработчик по вашему ~~эскизу~~ классу может ~~выковать~~ создать сколько угодно ~~отличных мечей~~ объектов.